FixedSizeArrays support (And Memory Support) #1669

Qfl3x · 2025-09-16T11:20:15Z

#1649
Struggling with the Memory object. This is what I'm getting currently:

ERROR: NoFieldMatchError:
Cannot convert type Memory{Float32}, best attempt Memory{ConcretePJRTNumber{Float32, 1, Reactant.Sharding.ShardInfo{Reactant.Sharding.NoSharding, Nothing}}} failed.
This could be because the type does not capture the fieldtypes that should be converted in its type parameters.
name=length idx=1 Derived: ConcretePJRTNumber{Int64, 1, Reactant.Sharding.ShardInfo{Reactant.Sharding.NoSharding, Nothing}} Existing: Int64 Best Attempt: Int64
name=ptr idx=2 Derived: Ptr{Nothing} Existing: Ptr{Nothing} Best Attempt: Ptr{Nothing}

Stacktrace:
  [1] traced_type_inner(T::Type, seen::Dict{Type, Type}, mode::Reactant.TraceMode, track_numbers::Type, sharding::Any, runtime::Any)
    @ Reactant ~/projects/Reactant.jl/src/Tracing.jl:759
  [2] traced_type(T::Type, ::Val{Reactant.ArrayToConcrete}, track_numbers::Type, sharding::Reactant.Sharding.NoSharding, runtime::Val{:PJRT})
    @ Reactant ~/projects/Reactant.jl/src/Tracing.jl:870
  [3] make_tracer_unknown(seen::Reactant.OrderedIdDict{Any, Any}, prev::Any, path::Any, mode::Reactant.TraceMode; track_numbers::Type, sharding::Any, runtime::Any, kwargs::@Kwargs{device::Nothing, client::Nothing})
    @ Reactant ~/projects/Reactant.jl/src/Tracing.jl:1032
  [4] make_tracer_unknown
    @ ~/projects/Reactant.jl/src/Tracing.jl:1009 [inlined]
  [5] #make_tracer#191
    @ ~/projects/Reactant.jl/src/Tracing.jl:1146 [inlined]
  [6] make_tracer
    @ ~/projects/Reactant.jl/src/Tracing.jl:1136 [inlined]
  [7] make_tracer(seen::Reactant.OrderedIdDict{…}, prev::FixedSizeArray{…}, path::Any, mode::Reactant.TraceMode; kwargs::@Kwargs{…})
    @ ReactantFixedSizeArraysExt ~/projects/Reactant.jl/ext/ReactantFixedSizeArraysExt.jl:27
  [8] to_rarray_internal(x::Any, track_numbers::Type, sharding::Any, runtime::Any, device::Any, client::Any)
    @ Reactant ~/projects/Reactant.jl/src/Tracing.jl:1848
  [9] #to_rarray#156
    @ ~/projects/Reactant.jl/src/Tracing.jl:1841 [inlined]
 [10] to_rarray(x::Any)
    @ Reactant ~/projects/Reactant.jl/src/Tracing.jl:1827
 [11] top-level scope
    @ REPL[10]:1
Some type information was truncated. Use `show(err)` to see complete types.

codecov · 2025-09-16T11:47:34Z

Codecov Report

❌ Patch coverage is 75.60976% with 10 lines in your changes missing coverage. Please review.
✅ Project coverage is 69.82%. Comparing base (b39a1fc) to head (a033cc6).
⚠️ Report is 3 commits behind head on main.

Files with missing lines	Patch %	Lines
src/xla/IFRT/Array.jl	50.00%	7 Missing ⚠️
ext/ReactantFixedSizeArraysExt.jl	50.00%	3 Missing ⚠️

Additional details and impacted files

@@            Coverage Diff             @@
##             main    #1669      +/-   ##
==========================================
+ Coverage   68.16%   69.82%   +1.66%     
==========================================
  Files         109      111       +2     
  Lines       11779    12157     +378     
==========================================
+ Hits         8029     8489     +460     
+ Misses       3750     3668      -82

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

ext/ReactantFixedSizeArraysExt.jl

Qfl3x · 2025-09-17T09:43:24Z

With the latest commit, I'm outputting a ConcretePJRTArray rather than a FixedSizeArray and assuming the default memory backend. So perhaps there is more work to do.

It turned out to be more intricate than I initially thought, as I had to add support for Memory as well. This may need some thinking over.

In addition, I stumbled on the fact that IFRT is broken for Arrays at least: #1672

Tests are still to be done. If this is shippable I'll start writing tests for it. (and for Memory too)

Qfl3x · 2025-09-17T10:12:25Z

Hmm, the builds are failing because they're running on v1.10 and Memory isn't defined there

giordano · 2025-09-17T10:16:51Z

You can guard the Memory-specific bits with

if isdefined(Base, :Memory)
    # ...
end

Relatedly, note that FixedSizeArrays.jl uses Memory only in v1.11+: https://juliaarrays.github.io/FixedSizeArrays.jl/stable/usage/#The-memory-backend

Qfl3x · 2025-09-18T09:31:55Z

I've found a problem with this implementation, it only works in the 1D case. the parent of a FixedSizeArray{T,N} is always a Memory object with 1 Dimension, the shape of the array is stored in the original FixedSizeArray.

In the latest commit, I reshaped the RArray to the shape of the underlying FixedSizeArray.

src/xla/IFRT/Array.jl

src/xla/PJRT/Buffer.jl

Qfl3x · 2025-09-19T13:31:04Z

Those parts have been refactored into their own functions (with AbstractArray{T,N} as a type.

avik-pal · 2025-09-19T14:22:14Z

1D: Error During Test at D:\a\Reactant.jl\Reactant.jl\test\integration\fixedsizearrays.jl:7
  Got exception outside of a @test
  UndefVarError: `array` not defined in `Reactant.XLA.PJRT`
  Stacktrace:
    [1] Reactant.XLA.PJRT.Buffer(client::Reactant.XLA.PJRT.Client, memory::Memory{Float32}, device::Reactant.XLA.PJRT.Device)
      @ Reactant.XLA.PJRT D:\a\Reactant.jl\Reactant.jl\src\xla\PJRT\Buffer.jl:31
    [2] Reactant.XLA.PJRT.AsyncBuffer(::Reactant.XLA.PJRT.Client, ::Vararg{Any}; kwargs::@Kwargs{})
      @ Reactant.XLA.PJRT D:\a\Reactant.jl\Reactant.jl\src\xla\PJRT\AsyncBuffer.jl:8
    [3] AsyncBuffer
      @ D:\a\Reactant.jl\Reactant.jl\src\xla\PJRT\AsyncBuffer.jl:8 [inlined]
    [4] NoSharding
      @ D:\a\Reactant.jl\Reactant.jl\src\Sharding.jl:193 [inlined]
    [5] make_concrete_PJRT_array(data::Memory{Float32}, client::Nothing, idx::Nothing, device::Nothing, sharding::Reactant.Sharding.NoSharding)
      @ Reactant D:\a\Reactant.jl\Reactant.jl\src\Types.jl:225
    [6] #ConcretePJRTArray#35
      @ D:\a\Reactant.jl\Reactant.jl\src\Types.jl:249 [inlined]
    [7] make_tracer_array(::Reactant.OrderedIdDict{Any, Any}, ::AbstractArray, ::Any, ::Reactant.TraceMode, ::Type, ::Any, ::Any, ::Any, ::Any)
      @ Reactant D:\a\Reactant.jl\Reactant.jl\src\Tracing.jl:1544
    [8] #make_tracer#162
      @ D:\a\Reactant.jl\Reactant.jl\src\Tracing.jl:1843 [inlined]
    [9] make_tracer
      @ D:\a\Reactant.jl\Reactant.jl\src\Tracing.jl:1831 [inlined]
   [10] make_tracer(seen::Reactant.OrderedIdDict{Any, Any}, prev::FixedSizeArrays.FixedSizeArray{Float32, 1, Memory{Float32}}, path::Any, mode::Reactant.TraceMode; kwargs::@Kwargs{track_numbers::Core.TypeofBottom, sharding::Reactant.Sharding.NoSharding, runtime::Val{:PJRT}, device::Nothing, client::Nothing})
      @ ReactantFixedSizeArraysExt D:\a\Reactant.jl\Reactant.jl\ext\ReactantFixedSizeArraysExt.jl:28
   [11] to_rarray_internal(x::Any, track_numbers::Type, sharding::Any, runtime::Any, device::Any, client::Any)
      @ Reactant D:\a\Reactant.jl\Reactant.jl\src\Tracing.jl:1881

probably should be memory instead of array

src/xla/PJRT/Buffer.jl

giordano · 2025-09-19T21:55:12Z

https://github.com/EnzymeAD/Reactant.jl/actions/runs/17861101375/job/50791872236?pr=1669#step:11:920

Memory test: Error During Test at /home/runner/work/Reactant.jl/Reactant.jl/test/memory.jl:5
  Got exception outside of a @test
  MethodError: no method matching make_buffer_array(::Reactant.XLA.PJRT.Client, ::Memory{Float32}, ::Reactant.XLA.PJRT.Device)
  The function `make_buffer_array` exists, but no method is defined for this combination of argument types.
  
  Closest candidates are:
    make_buffer_array(::Reactant.XLA.PJRT.Client, ::Array{T, N}, ::Reactant.XLA.PJRT.Device) where {T, N}
     @ Reactant ~/work/Reactant.jl/Reactant.jl/src/xla/PJRT/Buffer.jl:9
  
  Stacktrace:
    [1] Reactant.XLA.PJRT.Buffer(client::Reactant.XLA.PJRT.Client, memory::Memory{Float32}, device::Reactant.XLA.PJRT.Device)
      @ Reactant.XLA.PJRT ~/work/Reactant.jl/Reactant.jl/src/xla/PJRT/Buffer.jl:31
    [2] Reactant.XLA.PJRT.AsyncBuffer(::Reactant.XLA.PJRT.Client, ::Vararg{Any}; kwargs::@Kwargs{})
      @ Reactant.XLA.PJRT ~/work/Reactant.jl/Reactant.jl/src/xla/PJRT/AsyncBuffer.jl:8
    [3] (::Reactant.Sharding.NoSharding)(client::Reactant.XLA.PJRT.Client, device::Reactant.XLA.PJRT.Device, x::Memory{Float32})
      @ Reactant.Sharding ~/work/Reactant.jl/Reactant.jl/src/Sharding.jl:193
    [4] make_concrete_PJRT_array(data::Memory{Float32}, client::Nothing, idx::Nothing, device::Nothing, sharding::Reactant.Sharding.NoSharding)
      @ Reactant ~/work/Reactant.jl/Reactant.jl/src/Types.jl:225
    [5] ConcretePJRTArray(data::Memory{Float32}; client::Nothing, idx::Nothing, device::Nothing, sharding::Reactant.Sharding.NoSharding)
      @ Reactant ~/work/Reactant.jl/Reactant.jl/src/Types.jl:249
    [6] make_tracer_array(::Reactant.OrderedIdDict{Any, Any}, ::AbstractArray, ::Any, ::Reactant.TraceMode, ::Type, ::Any, ::Any, ::Any, ::Any)
      @ Reactant ~/work/Reactant.jl/Reactant.jl/src/Tracing.jl:1544
    [7] #make_tracer#162
      @ ~/work/Reactant.jl/Reactant.jl/src/Tracing.jl:1843 [inlined]
    [8] to_rarray_internal(x::Any, track_numbers::Type, sharding::Any, runtime::Any, device::Any, client::Any)
      @ Reactant ~/work/Reactant.jl/Reactant.jl/src/Tracing.jl:1881
    [9] #to_rarray#164
      @ ~/work/Reactant.jl/Reactant.jl/src/Tracing.jl:1870 [inlined]
   [10] to_rarray(x::Any)
      @ Reactant ~/work/Reactant.jl/Reactant.jl/src/Tracing.jl:1860
   [11] macro expansion
      @ ~/work/Reactant.jl/Reactant.jl/test/memory.jl:7 [inlined]
   [12] macro expansion
      @ /opt/hostedtoolcache/julia/1.11.7/x64/share/julia/stdlib/v1.11/Test/src/Test.jl:1709 [inlined]
   [13] top-level scope
      @ ~/work/Reactant.jl/Reactant.jl/test/memory.jl:6
   [14] include(mod::Module, _path::String)
      @ Base ./Base.jl:562
   [15] include(x::String)
      @ Main.var"##Memory#257" ~/.julia/packages/SafeTestsets/raUNr/src/SafeTestsets.jl:28
   [16] macro expansion
      @ ~/.julia/packages/SafeTestsets/raUNr/src/SafeTestsets.jl:24 [inlined]
   [17] macro expansion
      @ /opt/hostedtoolcache/julia/1.11.7/x64/share/julia/stdlib/v1.11/Test/src/Test.jl:1709 [inlined]
   [18] top-level scope
      @ ~/.julia/packages/SafeTestsets/raUNr/src/SafeTestsets.jl:24
   [19] eval(m::Module, e::Any)
      @ Core ./boot.jl:430
   [20] macro expansion
      @ ~/.julia/packages/SafeTestsets/raUNr/src/SafeTestsets.jl:28 [inlined]
   [21] macro expansion
      @ ~/work/Reactant.jl/Reactant.jl/test/runtests.jl:42 [inlined]
   [22] macro expansion
      @ /opt/hostedtoolcache/julia/1.11.7/x64/share/julia/stdlib/v1.11/Test/src/Test.jl:1709 [inlined]
   [23] top-level scope
      @ ~/work/Reactant.jl/Reactant.jl/test/runtests.jl:10
   [24] include(fname::String)
      @ Main ./sysimg.jl:38
   [25] top-level scope
      @ none:6

I can also reproduce it with

julia> using FixedSizeArrays, Reactant

julia> x = FixedSizeArray(randn(3, 4));

julia> rx = Reactant.to_rarray(x);
ERROR: MethodError: no method matching make_buffer_array(::Reactant.XLA.PJRT.Client, ::Memory{Float64}, ::Reactant.XLA.PJRT.Device)
The function `make_buffer_array` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  make_buffer_array(::Reactant.XLA.PJRT.Client, ::Array{T, N}, ::Reactant.XLA.PJRT.Device) where {T, N}
   @ Reactant ~/.julia/packages/Reactant/eaYLR/src/xla/PJRT/Buffer.jl:9

Stacktrace:

giordano · 2025-09-23T21:43:49Z

src/Types.jl

+@inline ConcreteRArray{T}(::UndefInitializer, shape::Integer...; kwargs...) where {T} = ConcreteRArray{
+    T
+}(
+    undef, Dims(shape); kwargs...
+)


https://github.com/EnzymeAD/Reactant.jl/actions/runs/17949332627/job/51048248283?pr=1669#step:2:570

Suggested change

@inline ConcreteRArray{T}(::UndefInitializer, shape::Integer...; kwargs...) where {T} = ConcreteRArray{

T

}(

undef, Dims(shape); kwargs...

)

@inline ConcreteRArray{T}(::UndefInitializer, shape::Integer...; kwargs...) where {T} =

ConcreteRArray{T}(undef, Dims(shape); kwargs...)

giordano · 2025-09-23T21:51:02Z

julia> using FixedSizeArrays, Reactant

julia> M = randn(3, 4);

julia> M_fs = FixedSizeMatrix(M);

julia> rM = Reactant.to_rarray(M);

julia> rM_fs = Reactant.to_rarray(M_fs);

julia> fn(x, y) = sin.(x) .+ cos.(y)
fn (generic function with 1 method)

julia> @code_hlo fn(rM, rM)
module @reactant_fn attributes {mhlo.num_partitions = 1 : i64, mhlo.num_replicas = 1 : i64} {
  func.func @main(%arg0: tensor<4x3xf64>) -> tensor<4x3xf64> attributes {enzymexla.memory_effects = []} {
    %0 = stablehlo.sine %arg0 : tensor<4x3xf64>
    %1 = stablehlo.cosine %arg0 : tensor<4x3xf64>
    %2 = stablehlo.add %0, %1 : tensor<4x3xf64>
    return %2 : tensor<4x3xf64>
  }
}

julia> @code_hlo fn(rM_fs, rM_fs)
module @reactant_fn attributes {mhlo.num_partitions = 1 : i64, mhlo.num_replicas = 1 : i64} {
  func.func @main(%arg0: tensor<12xf64>) -> tensor<4x3xf64> attributes {enzymexla.memory_effects = []} {
    %0 = stablehlo.reshape %arg0 : (tensor<12xf64>) -> tensor<4x3xf64>
    %1 = stablehlo.sine %0 : tensor<4x3xf64>
    %2 = stablehlo.cosine %0 : tensor<4x3xf64>
    %3 = stablehlo.add %1, %2 : tensor<4x3xf64>
    return %3 : tensor<4x3xf64>
  }
}

Why there's an extra stablehlo.reshape? That looks not ideal?

wsmoses · 2025-09-23T21:54:22Z

presumably the memory itself is being stored 1-dimensionally

giordano · 2025-09-23T21:55:31Z

It is, as it the case for Array though, the memory backend is basically the same.

giordano · 2025-09-23T21:57:33Z

ext/ReactantFixedSizeArraysExt.jl

+    kwargs...,
+) where {T,N}
+    shape = size(prev)
+    return reshape(


I guess this reshape is the culprit? How does Array work? Is it possible to construct this object directly with the right size instead of reshaping it?

but array itself we override to keep the dimensionality and allocate everything ourselves for Array.

if the actual tracing of a fixedsizearray does the current "generic recursion into structs" it will eventually allocate a 1-dim memory, always

The whole point of FixedSizeArray is that the size is...well...fixed. Having to reshape it all the time seems to go into the opposite direction, especially when Array doesn't have that.

It feels to me like make_tracer should take the size as an (optional) argument. Looking at

Reactant.jl/src/Tracing.jl

Lines 1177 to 1196 in e4bb34f

Base.@nospecializeinfer function make_tracer(

seen,

@nospecialize(prev::ConcreteIFRTArray{T,N}),

@nospecialize(path),

mode;

@nospecialize(sharding = Sharding.NoSharding()),

@nospecialize(device = nothing),

@nospecialize(client = nothing),

kwargs...,

) where {T,N}

if mode == TracedToTypes

throw("Cannot have ConcreteIFRTArray as function call argument.")

end

mode == ArrayToConcrete && return ConcreteIFRTArray(prev; sharding, device, client)

mode != ConcreteToTraced && throw("Cannot trace concrete")

haskey(seen, prev) && return seen[prev]::TracedRArray{T,N}

res = TracedRArray{T,N}((path,), nothing, size(prev))

seen[prev] = res

return res

end

(and all similar methods) the size could be another argument which defaults to size(prev) but could be overridden if passed explicitly.

I opened #1712 to implement my suggestion.

This function needs to be updated to return a FixedSizedArray where the internal data would be a Traced/Concrete Array (#1669 (comment))

I guess I'm missing something fundamental: Array has the same memory backend, why should FixedSizeArray be any different?

Array maps to our Concrete/Traced Array. For all "wrapped" types, we need to preserve the wrapper type, if we want the outputs to preserve the wrapped type. Else any operation you perform on a FixedSizeArray with inevitably be mapped to an Array output

I'm not really convinced a proposal for changing the memory backend in FixedSizeArrays is going to fly: it's meant to follow Array very closely, and the memory backend is always a flattened dense vector.

I mean once #1696 goes in, I think we should be able to make that work (though the backing memory might need to be a reshape(tracedrarray{n}, 1), but the reshape will optimize out with the one that's emitted currently

avik-pal · 2025-09-24T12:20:33Z

julia> M_fs = FixedSizeMatrix(M)
3×4 FixedSizeArray{Float64, 2, Memory{Float64}}:
  0.94348    2.80883  0.565887  -0.626701
 -0.235831  -1.81099  0.232086  -0.460039
  0.816708   1.20653  1.16788   -2.09359

julia> rM_fs = Reactant.to_rarray(M_fs)
3×4 reshape(::ConcretePJRTArray{Float64,1}, 3, 4) with eltype Float64:
  0.94348    2.80883  0.565887  -0.626701
 -0.235831  -1.81099  0.232086  -0.460039
  0.816708   1.20653  1.16788   -2.09359

we shouldn't unwrap the array type here

avik-pal · 2025-09-24T12:21:46Z

ext/ReactantFixedSizeArraysExt.jl

+using FixedSizeArrays
+using Reactant
+using Reactant: TracedRArray, TracedRNumber, Ops
+using ReactantCore: ReactantCore


Suggested change

using FixedSizeArrays

using Reactant

using Reactant: TracedRArray, TracedRNumber, Ops

using ReactantCore: ReactantCore

using FixedSizeArrays: FixedSizeArrayDefault

using Reactant: Reactant, TracedRArray, TracedRNumber, Ops

using ReactantCore: ReactantCore

avik-pal · 2025-09-24T12:21:53Z

ext/ReactantFixedSizeArraysExt.jl

+using ReactantCore: ReactantCore
+
+function Reactant.traced_type_inner(
+    @nospecialize(_::Type{FixedSizeArrays.FixedSizeArrayDefault{T,N}}),


Suggested change

@nospecialize(_::Type{FixedSizeArrays.FixedSizeArrayDefault{T,N}}),

@nospecialize(_::Type{FixedSizeArrayDefault{T,N}}),

avik-pal · 2025-09-24T12:22:03Z

ext/ReactantFixedSizeArraysExt.jl

+
+Base.@nospecializeinfer function Reactant.make_tracer(
+    seen,
+    @nospecialize(prev::FixedSizeArrays.FixedSizeArrayDefault{T,N}),


Suggested change

@nospecialize(prev::FixedSizeArrays.FixedSizeArrayDefault{T,N}),

@nospecialize(prev::FixedSizeArrayDefault{T,N}),

avik-pal · 2025-09-24T12:22:20Z

ext/ReactantFixedSizeArraysExt.jl

+    kwargs...,
+) where {T,N}
+    shape = size(prev)
+    return reshape(


Missing the call to FixedSizedArray

Returning a FixedSizeArray causes problems.

With track_numbers=Number I get this: (@jit(f(rx)))

ERROR: TypeError: in RNumber, in T, expected T<:Union{Complex{Int16}, Complex{Int32}, Complex{Int64}, Complex{Int8}, Complex{UInt16}, Complex{UInt32}, Complex{UInt64}, Complex{UInt8}, Core.BFloat16, Bool, Float16, Float32, Float64, Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Reactant.F8E4M3B11FNUZ, Reactant.F8E4M3FN, Reactant.F8E4M3FNUZ, Reactant.F8E5M2, Reactant.F8E5M2FNUZ, ComplexF64, ComplexF32}, got Type{Reactant.TracedRNumber{Float32}} Stacktrace: [1] copyto!(dest::Memory{Reactant.TracedRNumber{Float32}}, src::Vector{Reactant.TracedRNumber{Float32}}) @ Reactant.TracedRArrayOverrides ~/projects/Reactant.jl/src/TracedRArray.jl:492 [2] collect_as_vectorlike_with_known_eltype_and_length(::Type{Memory{Reactant.TracedRNumber{Float32}}}, collection::Vector{Reactant.TracedRNumber{Float32}}) @ Collects ~/.julia/packages/Collects/iMuH5/src/Collects.jl:269 [3] collect_as_memory_with_known_eltype_and_known_length(::Type{Reactant.TracedRNumber{Float32}}, collection::Vector{Reactant.TracedRNumber{Float32}}) @ Collects ~/.julia/packages/Collects/iMuH5/src/Collects.jl:345 [4] collect_as_memory_with_known_eltype(::Type{Reactant.TracedRNumber{Float32}}, collection::Vector{Reactant.TracedRNumber{Float32}}) @ Collects ~/.julia/packages/Collects/iMuH5/src/Collects.jl:353 [5] collect_as_memory(::Function, ::Type{Memory{Reactant.TracedRNumber{Float32}}}, collection::Vector{Reactant.TracedRNumber{Float32}}) @ Collects ~/.julia/packages/Collects/iMuH5/src/Collects.jl:373 [6] collect_as_common_invariant(e::typeof(Collects.EmptyIteratorHandling.just_throws), ::Type{Memory{Reactant.TracedRNumber{Float32}}}, collection::Vector{Reactant.TracedRNumber{Float32}}) @ Collects ~/.julia/packages/Collects/iMuH5/src/Collects.jl:376 [7] collect_as_common(e::typeof(Collects.EmptyIteratorHandling.just_throws), type::Type{Memory{Reactant.TracedRNumber{Float32}}}, collection::Vector{Reactant.TracedRNumber{Float32}}) @ Collects ~/.julia/packages/Collects/iMuH5/src/Collects.jl:400 [8] (::Collects.Collect{typeof(Collects.EmptyIteratorHandling.just_throws)})(type::Type{Memory{Reactant.TracedRNumber{Float32}}}, collection::Vector{Reactant.TracedRNumber{Float32}}) @ Collects ~/.julia/packages/Collects/iMuH5/src/Collects.jl:411 [9] (::Collects.Collect{typeof(Collects.EmptyIteratorHandling.just_throws)})(::Type{FixedSizeArrayDefault{Reactant.TracedRNumber{Float32}}}, iterator::Vector{Reactant.TracedRNumber{Float32}}) @ FixedSizeArrays ~/.julia/packages/FixedSizeArrays/VHLXx/src/collect_as.jl:45 [10] collect_as(::Type{FixedSizeArrayDefault{Reactant.TracedRNumber{Float32}}}, collection::Vector{Reactant.TracedRNumber{Float32}}; empty_iterator_handler::typeof(Collects.EmptyIteratorHandling.just_throws)) @ Collects ~/.julia/packages/Collects/iMuH5/src/Collects.jl:425 [11] collect_as(::Type{FixedSizeArrayDefault{Reactant.TracedRNumber{Float32}}}, collection::Vector{Reactant.TracedRNumber{Float32}}) @ Collects ~/.julia/packages/Collects/iMuH5/src/Collects.jl:423 [12] collect_as_haseltype(::Type{FixedSizeArrayDefault}, iterator::Vector{Reactant.TracedRNumber{Float32}}) @ FixedSizeArrays ~/.julia/packages/FixedSizeArrays/VHLXx/src/collect_as.jl:56 [13] converting_constructor(::Type{FixedSizeArrayDefault}, src::Vector{Reactant.TracedRNumber{Float32}}) @ FixedSizeArrays ~/.julia/packages/FixedSizeArrays/VHLXx/src/FixedSizeArray.jl:334 [14] (FixedSizeArrayDefault)(src::Vector{Reactant.TracedRNumber{Float32}}) @ FixedSizeArrays ~/.julia/packages/FixedSizeArrays/VHLXx/src/FixedSizeArray.jl:345 [15] make_tracer(seen::Reactant.OrderedIdDict{Any, Any}, prev::FixedSizeArray{Float32, 1, Memory{Float32}}, path::Any, mode::Reactant.TraceMode; kwargs::@Kwargs{runtime::Val{:PJRT}}) @ ReactantFixedSizeArraysExt ~/projects/Reactant.jl/ext/ReactantFixedSizeArraysExt.jl:33

I don't know why it's throwing this, as after inspection the inner Memory object is traced properly.

Without it I get:

ERROR: cannot copy Ptr{Nothing} @0x0000795f973dc1e0 of type Ptr{Nothing} Stacktrace: [1] error(s::String) @ Base ./error.jl:35 [2] create_result(tocopy::Ptr{…}, path::Tuple{…}, result_stores::Dict{…}, path_to_shard_info::Nothing, to_unreshard_results::Dict{…}, unresharded_code::Vector{…}, unresharded_arrays_cache::Dict{…}, used_shardinfo::Set{…}, result_cache::IdDict{…}, var_idx::Base.RefValue{…}, resultgen_code::Vector{…}) @ Reactant.Compiler ~/projects/Reactant.jl/src/Compiler.jl:231 [3] create_result(tocopy::Memory{…}, path::Tuple{…}, result_stores::Dict{…}, path_to_shard_info::Nothing, to_unreshard_results::Dict{…}, unresharded_code::Vector{…}, unresharded_arrays_cache::Dict{…}, used_shardinfo::Set{…}, result_cache::IdDict{…}, var_idx::Base.RefValue{…}, resultgen_code::Vector{…}) @ Reactant.Compiler ~/projects/Reactant.jl/src/Compiler.jl:256 [4] create_result(tocopy::FixedSizeArray{…}, path::Tuple{}, result_stores::Dict{…}, path_to_shard_info::Nothing, to_unreshard_results::Dict{…}, unresharded_code::Vector{…}, unresharded_arrays_cache::Dict{…}, used_shardinfo::Set{…}, result_cache::IdDict{…}, var_idx::Base.RefValue{…}, resultgen_code::Vector{…}) @ Reactant.Compiler ~/projects/Reactant.jl/src/Compiler.jl:256 [5] codegen_unflatten!(linear_args::Vector{…}, preserved_args::Vector{…}, concretized_res_names::Vector{…}, linear_results::Vector{…}, concrete_result::FixedSizeArray{…}, result_stores::Dict{…}, path_to_shard_info::Nothing, linear_result_shard_info::Vector{…}, client::Reactant.XLA.PJRT.Client, resharded_inputs::Dict{…}) @ Reactant.Compiler ~/projects/Reactant.jl/src/Compiler.jl:3147 [6] compile(f::Function, args::Tuple{…}; kwargs::@Kwargs{…}) @ Reactant.Compiler ~/projects/Reactant.jl/src/Compiler.jl:3599 [7] top-level scope @ ~/projects/Reactant.jl/src/Compiler.jl:2614

For this one I don't have a clue.

So:

mem = Memory{Float32}([1.0f0, 2.0f0]) getfield(mem, 2)

Ptr{nothing} <pointer address>

This is where the pointer is coming from.

Since Reactant isn't supporting resizing for normal arrays, and FixedSizeArray isn't doing any fancy memory/optimization stuff other than fixed size (unlike OneHotArrays, FillArrays) shouldn't it be fine for the FixedSizeArray to transform into an ordinary Concrete Array?

giordano reviewed Sep 16, 2025

View reviewed changes

ext/ReactantFixedSizeArraysExt.jl Outdated Show resolved Hide resolved

Qfl3x changed the title ~~[WIP] FixedSizeArrays support~~ [WIP] FixedSizeArrays support (And Memory Support) Sep 17, 2025

Qfl3x added 7 commits September 18, 2025 11:33

WIP FixedSizeArrays support

e0906bc

Removed debug messages

460dd4c

FixedSizeArray -> ConcreteArray

73205e2

Project cleanup

15eca0b

Safeguard Memory for v1.10

cbd5e75

Formatter

702ac1d

support for N dim arrays, tests

658a3d7

Qfl3x force-pushed the FixedSizeArrays_support branch from 8625b1a to 658a3d7 Compare September 18, 2025 09:35

Qfl3x added 3 commits September 18, 2025 11:53

formatting

7e79d15

IFRT support for Memory and FixedSizeArrays

08a425e

Formatter pass

8b9f24d

avik-pal reviewed Sep 18, 2025

View reviewed changes

src/xla/IFRT/Array.jl Outdated Show resolved Hide resolved

src/xla/IFRT/Array.jl Outdated Show resolved Hide resolved

src/xla/IFRT/Array.jl Show resolved Hide resolved

src/xla/PJRT/Buffer.jl Show resolved Hide resolved

Refactored Array and Memory common code

dc00c6a

avik-pal reviewed Sep 19, 2025

View reviewed changes

src/xla/PJRT/Buffer.jl Outdated Show resolved Hide resolved

Update src/xla/PJRT/Buffer.jl

ff2d39b

avik-pal requested a review from giordano September 19, 2025 14:23

Qfl3x and others added 4 commits September 22, 2025 07:54

Fixed make_buffer_array

995c8a3

Merge branch 'main' into FixedSizeArrays_support

8ef1575

formatting

c1842c3

Merge branch 'main' into FixedSizeArrays_support

a033cc6

avik-pal changed the title ~~[WIP] FixedSizeArrays support (And Memory Support)~~ FixedSizeArrays support (And Memory Support) Sep 23, 2025

avik-pal approved these changes Sep 23, 2025

View reviewed changes

giordano reviewed Sep 23, 2025

View reviewed changes

avik-pal self-requested a review September 24, 2025 12:20

avik-pal reviewed Sep 24, 2025

View reviewed changes

giordano mentioned this pull request Sep 27, 2025

Allow passing custom size to Array-like make_tracer methods #1712

Open

	Base.@nospecializeinfer function make_tracer(
	seen,
	@nospecialize(prev::ConcreteIFRTArray{T,N}),
	@nospecialize(path),
	mode;
	@nospecialize(sharding = Sharding.NoSharding()),
	@nospecialize(device = nothing),
	@nospecialize(client = nothing),
	kwargs...,
	) where {T,N}
	if mode == TracedToTypes
	throw("Cannot have ConcreteIFRTArray as function call argument.")
	end
	mode == ArrayToConcrete && return ConcreteIFRTArray(prev; sharding, device, client)
	mode != ConcreteToTraced && throw("Cannot trace concrete")
	haskey(seen, prev) && return seen[prev]::TracedRArray{T,N}
	res = TracedRArray{T,N}((path,), nothing, size(prev))
	seen[prev] = res
	return res
	end

	@nospecialize(_::Type{FixedSizeArrays.FixedSizeArrayDefault{T,N}}),
	@nospecialize(_::Type{FixedSizeArrayDefault{T,N}}),

	@nospecialize(prev::FixedSizeArrays.FixedSizeArrayDefault{T,N}),
	@nospecialize(prev::FixedSizeArrayDefault{T,N}),

FixedSizeArrays support (And Memory Support) #1669

Are you sure you want to change the base?

FixedSizeArrays support (And Memory Support) #1669

Uh oh!

Conversation

Qfl3x commented Sep 16, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

codecov bot commented Sep 16, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Codecov Report

Uh oh!

Uh oh!

Qfl3x commented Sep 17, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Qfl3x commented Sep 17, 2025

Uh oh!

giordano commented Sep 17, 2025

Uh oh!

Qfl3x commented Sep 18, 2025

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Qfl3x commented Sep 19, 2025

Uh oh!

avik-pal commented Sep 19, 2025

Uh oh!

Uh oh!

giordano commented Sep 19, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

giordano commented Sep 23, 2025

Uh oh!

wsmoses commented Sep 23, 2025

Uh oh!

giordano commented Sep 23, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

giordano Sep 23, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

giordano Sep 23, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

avik-pal commented Sep 24, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Qfl3x Sep 30, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Qfl3x commented Sep 16, 2025 •

edited

Loading

codecov bot commented Sep 16, 2025 •

edited

Loading

Qfl3x commented Sep 17, 2025 •

edited

Loading

giordano Sep 23, 2025 •

edited

Loading

giordano Sep 23, 2025 •

edited

Loading

Qfl3x Sep 30, 2025 •

edited

Loading